package com.weblog.article.utils;

import com.weblog.article.dao.CategoryDao;
import com.weblog.model.article.Category;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author MaoLin Wang
 * @date 2019/10/17:19
 */
public  class TreeOperationUtil {

    @Autowired
    private CategoryDao categoryDao;

    //(删除时)存储父节点的儿子的所有后代
    private Map<Integer, List<Category>> resultMap=new HashMap<>();

    /**
     * 存储修改时待修改集合
     */
    private List<Category>categories=new ArrayList<>();

    /**
     * 删除操作
     * @param id
     * @param isparent
     */
    public void handleDelete(String id ,String isparent){
        //是父类目
        if("1".equals(isparent)){
            //查询出该父类目的所有第一级的子类目
            categoryDao.updateStateById("0",id);
            List<Category> sonData = categoryDao.findCategoriesByParentId(id);
            //儿子的所有后代
            Map<Integer, List<Category>> sonOffspringsMap =diguiTree(sonData);
            //取出集合
            List<Category> sonOffspringsList = sonOffspringsMap.get(1);
            //每次执行一次删除后，清空结果集，否则会将上一次删除的记录一并删除
            resultMap.clear();
            if(sonOffspringsList!=null){
                //两个集合合并
                sonData.addAll(sonOffspringsList);
            }
            for(Category category:sonData){
                categoryDao.updateStateById("0",category.getId());
            }
        }
    }
    /**
     * 递归遍历儿子节点
     * @param list
     * @return
     */
    private   Map<Integer,List<Category>> diguiTree(List<Category> list ){
        //存储需要递归的集合，即在一次遍历中将所有是父节点的数据存入该集合
        Map<Integer,List<Category>>diguiMap=new HashMap<>();
        //存储当前节点的孩子
        List<Category> clist=null;
        //计数器，判断循环了几次
        int count=0;
        for(int i=0;i<list.size();i++){
            //是父类目
            if("1".equals(list.get(i).getIsparent())) {
                count++;
                //查询该节点的孩子
                clist = categoryDao.findCategoriesByParentId(list.get(i).getId());
                if (count > 1) {
                    //循环了两次，需要向递归map中添加集合
                    if (clist.size() > 0) {
                        List<Category> diguiC = diguiMap.get(1);
                        for (int j = 0; j < clist.size(); j++) {

                            diguiC.add(clist.get(j));
                        }
                        diguiMap.put(1, diguiC);
                    }
                } else {
                    //第一次循环，直接将需要递归的集合放入map
                    diguiMap.put(1, clist);

                }
                continue;
            }
        }
        //获取待递归map中的集合
        List<Category>currentLevelData= diguiMap.get(1);
        //获取最终集合
        List<Category> categories = resultMap.get(1);
        //当仅当二者不为空时，向最终集合中添加待递归数据，因为如果不是待递归节点，即不是父节点，则此节点会在上一次循环中被添加到该集合
        if(categories!=null&&currentLevelData!=null){
            for(Category c2:currentLevelData){
                categories.add(c2);
            }
            resultMap.put(1,categories);
        }else {
            //最后一次递归时，若最后的节点不是父类目，则currentLevelData为空，需加此判断
            if(currentLevelData!=null){
                resultMap.put(1,currentLevelData);
            }
        }
        //待递归集合非空时进行递归
        if(currentLevelData!=null){
            diguiTree(currentLevelData);
        }

        return resultMap;

    }


    /**
     * 修改操作
     * @param category
     */
    public void handleUpdate(Category category){
        //修改前的分类
        Category proCategory = categoryDao.findById(category.getId()).get();
        if (!proCategory.getCname().equals(category.getCname()) || !proCategory.getState().equals(category.getState())) {
            //修改了
            if(category.getState().equals(proCategory.getState())){
                //只修改了名字,未修改状态
                //直接更新
                categoryDao.save(category);
            }else {
                //修改了状态
                //约定前端在修改操作中只能添加使用，不能进行删除操作，所以状态只能被改为1
                categoryDao.save(category);
                List<Category> categories = diguiUp(category.getParentId(),false);
                for (Category c :categories){
                    categoryDao.updateStateById("1",c.getId());
                }
            }

        }
        //未作修改


    }

    /**
     * 向上递归查询待修改分类
     * @param parentid
     * @param isDigui
     * @return 返回待修改分类集合
     */
    private List<Category> diguiUp(String parentid, boolean isDigui){
        Category category = categoryDao.findById(parentid).get();//查询上级类目
       List<String>diguiCategory=new ArrayList<>();
        if("0".equals(category.getParentId())){
            //父类目为顶级类目
            categories.add(category);

            return categories;
        }else if("1".equals(category.getState())){
            //上级状态已经为1
            return categories;
        }else {
            categories.add(category);

            diguiCategory.add(category.getParentId());
            if(diguiCategory!=null&&diguiCategory.size()>0){
                diguiUp(category.getParentId(),true);
            }
            return categories;
        }
    }
}
